﻿using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using LiveTiss.Classes;
using LiveTiss.LiveTissWCF;

namespace LiveTiss.Telas
{
    public partial class ConfigChildWindow : ChildWindow, INotifyPropertyChanged
    {
        private LiveTissServiceClient client;

        private LiveTissServiceClient clientPrestadores;

        public ConfigChildWindow()
        {
            this.DataContext = this;

            client = new LiveTissServiceClient();
            clientPrestadores = new LiveTissServiceClient();

            this.InitializeProperties();
            this.RegisterEventHandlers();

            InitializeComponent();

            #region Operadoras
            this.OperadoraEnabled = false;
            btnExcluir.Visibility = System.Windows.Visibility.Collapsed;

            client.OperadoraGetAllAsync(Util.Token);
            #endregion

            #region Prestadores
            this.PrestadorEnabled = false;
            btnPrestadorExcluir.Visibility = System.Windows.Visibility.Collapsed;

            clientPrestadores.PrestadorGetAllAsync(Util.Token);
            #endregion

            #region Configuracoes
            client.OperadoraGetAllFiliadoAsync(Util.Token);
            client.OperadoraGetAllNaoFiliadoAsync(Util.Token);
            #endregion
        }

        private void InitializeProperties()
        {
            #region Operadora
            this.Operadora = new Operadora()
            {
                Logo = null,
                Nome = string.Empty,
                RegistroANS = string.Empty,
                Validate = false
            };
            #endregion

            #region Prestador
            this.Prestador = new LiveTissWCF.Prestador()
            {
                CEP = string.Empty,
                CodigoIBGE = string.Empty,
                CodigoUF = string.Empty,
                Complemento = string.Empty,
                Logradouro = string.Empty,
                Municipio = string.Empty,
                Nome = string.Empty,
                Numero = string.Empty,
                TipoLogradouro = string.Empty,
                Validate = true,
                LoginPrestador = Util.Login,
                ClinicaPrestador = null,
                ProfissionalPrestador = null
            };
            this.Prestador.Validate = true;
            this.Prestador.LoginPrestador.Validate = true;

            client.PrestadorGetByIdAsync(Util.Token, Util.Login.ID);
            #endregion

            #region PrestadorSelecionado
            this.PrestadorSelecionado = new LiveTissWCF.Prestador()
            {
                CEP = string.Empty,
                CodigoIBGE = string.Empty,
                CodigoUF = string.Empty,
                Complemento = string.Empty,
                Logradouro = string.Empty,
                Municipio = string.Empty,
                Nome = string.Empty,
                Numero = string.Empty,
                TipoLogradouro = string.Empty,
                Validate = false,
                LoginPrestador = new Login()
                {
                    IsAdministrator = false,
                    Senha = string.Empty,
                    SenhaNova = string.Empty,
                    SenhaConfirma = string.Empty,
                    Usuario = string.Empty,
                    Validate = false
                },
                ClinicaPrestador = null,
                ProfissionalPrestador = new Profissional()
                {
                    CBOS = string.Empty,
                    CPF = string.Empty,
                    NumeroConselho = string.Empty,
                    SiglaConselho = string.Empty,
                    UFConselho = string.Empty,
                    Validate = false
                }
            };
            #endregion
        }

        private void RegisterEventHandlers()
        {
            client.OperadoraInsertCompleted += new System.EventHandler<OperadoraInsertCompletedEventArgs>(client_OperadoraInsertCompleted);
            client.OperadoraGetAllCompleted += new System.EventHandler<OperadoraGetAllCompletedEventArgs>(client_OperadoraGetAllCompleted);
            client.OperadoraDeleteCompleted += new System.EventHandler<AsyncCompletedEventArgs>(client_OperadoraDeleteCompleted);
            client.OperadoraUpdateCompleted += new System.EventHandler<AsyncCompletedEventArgs>(client_OperadoraUpdateCompleted);
            client.PrestadorGetByIdCompleted += new System.EventHandler<PrestadorGetByIdCompletedEventArgs>(client_PrestadorGetByIdCompleted);
            client.PrestadorGetAllCompleted += new System.EventHandler<PrestadorGetAllCompletedEventArgs>(client_PrestadorGetAllCompleted);
            client.PrestadorUpdateCompleted += new System.EventHandler<AsyncCompletedEventArgs>(client_PrestadorUpdateCompleted);

            client.OperadoraGetAllFiliadoCompleted += new System.EventHandler<OperadoraGetAllFiliadoCompletedEventArgs>(client_OperadoraGetAllFiliadoCompleted);
            client.OperadoraGetAllNaoFiliadoCompleted += new System.EventHandler<OperadoraGetAllNaoFiliadoCompletedEventArgs>(client_OperadoraGetAllNaoFiliadoCompleted);
            client.OperadoraPrestadorGetByIdCompleted += new System.EventHandler<OperadoraPrestadorGetByIdCompletedEventArgs>(client_OperadoraPrestadorGetByIdCompleted);
            client.OperadoraPrestadorInsertCompleted += new System.EventHandler<OperadoraPrestadorInsertCompletedEventArgs>(client_OperadoraPrestadorInsertCompleted);
            client.OperadoraPrestadorUpdateCompleted += new System.EventHandler<AsyncCompletedEventArgs>(client_OperadoraPrestadorUpdateCompleted);
            client.OperadoraPrestadorDeleteCompleted += new System.EventHandler<AsyncCompletedEventArgs>(client_OperadoraPrestadorDeleteCompleted);

            client.IntervaloLoteGetAllByOperadoraPrestadorCompleted += new System.EventHandler<IntervaloLoteGetAllByOperadoraPrestadorCompletedEventArgs>(client_IntervaloLoteGetAllByOperadoraPrestadorCompleted);
            client.IntervaloLoteInsertCompleted += new System.EventHandler<IntervaloLoteInsertCompletedEventArgs>(client_IntervaloLoteInsertCompleted);
            client.IntervaloLoteUpdateCompleted += new System.EventHandler<AsyncCompletedEventArgs>(client_IntervaloLoteUpdateCompleted);
            
            clientPrestadores.PrestadorInsertCompleted += new System.EventHandler<PrestadorInsertCompletedEventArgs>(clientPrestadores_PrestadorInsertCompleted);
            clientPrestadores.PrestadorGetAllCompleted += new System.EventHandler<PrestadorGetAllCompletedEventArgs>(clientPrestadores_PrestadorGetAllCompleted);
            clientPrestadores.PrestadorDeleteCompleted += new System.EventHandler<AsyncCompletedEventArgs>(clientPrestadores_PrestadorDeleteCompleted);
            clientPrestadores.PrestadorUpdateCompleted += new System.EventHandler<AsyncCompletedEventArgs>(clientPrestadores_PrestadorUpdateCompleted);
        }

        #region Property Change Members

        public event PropertyChangedEventHandler PropertyChanged;

        private void FirePropertyChanged(string property)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(property));
            }
        }   

        #endregion

        #region Meus Dados

        private AuthenticationToken novoToken = null;

        #region Prestador
        public Prestador Prestador
        {
            get { return (Prestador)GetValue(PrestadorProperty); }
            set { SetValue(PrestadorProperty, value); }
        }

        public static readonly DependencyProperty PrestadorProperty =
            DependencyProperty.Register("Prestador", typeof(Prestador), typeof(ConfigChildWindow), new PropertyMetadata(null));
        #endregion

        #region MeusDadosNoErrors
        private int meusDadosErrorCount = 0;

        public bool MeusDadosNoErrors
        {
            get
            {
                return (meusDadosErrorCount == 0);
            }
        }
        #endregion

        private void meusDados_BindingValidationError(object sender, ValidationErrorEventArgs e)
        {
            switch (e.Action)
            {
                case ValidationErrorEventAction.Added:
                    meusDadosErrorCount++;
                    break;
                case ValidationErrorEventAction.Removed:
                    meusDadosErrorCount--;
                    break;
            }
            FirePropertyChanged("MeusDadosNoErrors");
        }

        private void txtSenha_LostFocus(object sender, RoutedEventArgs e)
        {
            BindingExpression bindingExpression = null;

            bindingExpression = txtSenha.GetBindingExpression(TextBox.TextProperty);
            bindingExpression.UpdateSource();

            bindingExpression = txtSenhaConfirma.GetBindingExpression(TextBox.TextProperty);
            bindingExpression.UpdateSource();
        }

        private void txtSenhaConfirma_LostFocus(object sender, RoutedEventArgs e)
        {
            BindingExpression bindingExpression = null;

            bindingExpression = txtSenhaConfirma.GetBindingExpression(TextBox.TextProperty);
            bindingExpression.UpdateSource();

            bindingExpression = txtSenha.GetBindingExpression(TextBox.TextProperty);
            bindingExpression.UpdateSource();
        }

        private void btnMeusDadosSalvar_Click(object sender, RoutedEventArgs e)
        {
            if (MeusDadosNoErrors)
            {
                if (!string.IsNullOrEmpty(this.Prestador.LoginPrestador.SenhaNova))
                {
                    novoToken = Util.GenerateToken(this.Prestador.LoginPrestador.Usuario,
                        this.Prestador.LoginPrestador.SenhaNova);
                }
                client.PrestadorUpdateAsync(Util.Token, this.Prestador);
            }
        }

        private void btnMeusDadosCancelar_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = false;
        }

        void client_PrestadorGetByIdCompleted(object sender, PrestadorGetByIdCompletedEventArgs e)
        {
            if (e.Result != null)
            {
                this.Prestador = e.Result as Prestador;
                this.Prestador.Validate = true;

                if (this.Prestador.ProfissionalPrestador != null)
                {
                    this.Prestador.ProfissionalPrestador.Validate = true;
                }
                if (this.Prestador.ClinicaPrestador != null)
                {
                    this.Prestador.ClinicaPrestador.Validate = true;
                }
                if (this.Prestador.LoginPrestador != null)
                {
                    this.Prestador.LoginPrestador.Validate = true;
                }
            }
        }

        void client_PrestadorGetAllCompleted(object sender, PrestadorGetAllCompletedEventArgs e)
        {
            throw new System.NotImplementedException();
        }

        void client_PrestadorUpdateCompleted(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                if (this.novoToken != null)
                {
                    Util.Token = this.novoToken;
                }
                this.Prestador = null;
                this.novoToken = null;
                client.PrestadorGetByIdAsync(Util.Token, Util.Login.ID);

                var alert = new AlertChildWindow();

                alert.Title = "Dados atualizados com sucesso!";
                alert.Width = 600;
                alert.Height = 150;

                alert.Show();
            }
        }

        #endregion

        #region Operadoras

        #region Operadoras
        public static readonly DependencyProperty OperadorasProperty = DependencyProperty.Register("Operadoras",
            typeof(ObservableCollection<Operadora>), typeof(ConfigChildWindow), new PropertyMetadata(null));

        public ObservableCollection<Operadora> Operadoras
        {
            get { return (ObservableCollection<Operadora>)GetValue(OperadorasProperty); }
            set { SetValue(OperadorasProperty, value); }
        }
        #endregion

        #region Operadora
        public static readonly DependencyProperty OperadoraProperty = DependencyProperty.Register("Operadora",
            typeof(Operadora), typeof(ConfigChildWindow), new PropertyMetadata(null));

        public Operadora Operadora
        {
            get { return (Operadora)GetValue(OperadoraProperty); }
            set { SetValue(OperadoraProperty, value); }
        }
        #endregion

        #region OperadoraEnabled
        public static readonly DependencyProperty OperadoraEnabledProperty = DependencyProperty.Register("OperadoraEnabled",
            typeof(bool), typeof(ConfigChildWindow), new PropertyMetadata(false, new PropertyChangedCallback(OperadoraEnabledChanged)));

        public bool OperadoraEnabled
        {
            get { return (bool)GetValue(OperadoraEnabledProperty); }
            set { SetValue(OperadoraEnabledProperty, value); }
        }

        private static void OperadoraEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ConfigChildWindow myControl = d as ConfigChildWindow;

            if (myControl != null)
            {
                myControl.FirePropertyChanged("OperadoraNoErrors");
            }
        }

        #endregion

        #region IsNewOperadora
        public static readonly DependencyProperty IsNewOperadoraProperty = DependencyProperty.Register("IsNewOperadora",
            typeof(bool), typeof(ConfigChildWindow), new PropertyMetadata(false));

        public bool IsNewOperadora
        {
            get { return (bool)GetValue(IsNewOperadoraProperty); }
            set { SetValue(IsNewOperadoraProperty, value); }
        }
        #endregion

        #region OperadoraNoErrors
        private int operadoraErrorCount = 0;

        public bool OperadoraNoErrors
        {
            get
            {
                return (operadoraErrorCount == 0 && OperadoraEnabled);
            }
        }  
        #endregion

        private void operadoras_BindingValidationError(object sender, ValidationErrorEventArgs e)
        {
            switch (e.Action)
            {
                case ValidationErrorEventAction.Added:
                    operadoraErrorCount++;
                    break;
                case ValidationErrorEventAction.Removed:
                    operadoraErrorCount--;
                    break;
            }
            FirePropertyChanged("OperadoraNoErrors");
        }

        private void LimparOperadora()
        {
            this.Operadora = new Operadora()
            {
                Logo = null,
                Nome = string.Empty,
                RegistroANS = string.Empty,
                Validate = false
            };

            lbxOperadora.SelectedIndex = -1;
            this.IsNewOperadora = false;
            this.OperadoraEnabled = false;
            btnExcluir.Visibility = System.Windows.Visibility.Collapsed;
        }

        private void btnSalvar_Click(object sender, RoutedEventArgs e)
        {
            if (OperadoraNoErrors)
            {
                if (this.IsNewOperadora)
                {
                    // Cadastrar novo
                    client.OperadoraInsertAsync(Util.Token, this.Operadora);
                }
                else
                {
                    // Salvar alterações
                    client.OperadoraUpdateAsync(Util.Token, this.Operadora);
                }
                LimparOperadora();
            }
        }

        private void btnCancelar_Click(object sender, RoutedEventArgs e)
        {
            LimparOperadora();
        }

        private void btnExcluir_Click(object sender, RoutedEventArgs e)
        {
            var alert = new AlertChildWindow();

            alert.Title = "Tem certeza que quer remover essa operadora?";
            alert.Width = 600;
            alert.Height = 200;

            alert.Closed += new System.EventHandler(alert_Closed);
            alert.Show(true);
        }

        private void alert_Closed(object sender, System.EventArgs e)
        {
            var alert = sender as AlertChildWindow;

            if ((bool)alert.DialogResult)
            {
                client.OperadoraDeleteAsync(Util.Token, this.Operadora);

                this.LimparOperadora();
            }
        }

        private void btnLogotipo_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog dialog = new OpenFileDialog();
            dialog.Multiselect = false;
            dialog.Filter = "Image Files (*.jpg;*.png)|*.jpg;*.png";

            if ((bool)dialog.ShowDialog())
            {
                byte[] buff = null;
                FileStream fs = dialog.File.OpenRead();
                BinaryReader br = new BinaryReader(fs);
                long numBytes = dialog.File.Length;
                buff = br.ReadBytes((int)numBytes);

                this.Operadora.Logo = buff;
            }
        }

        private void btnNovo_Click(object sender, RoutedEventArgs e)
        {
            this.Operadora = new Operadora()
            {
                Logo = null,
                Nome = string.Empty,
                RegistroANS = string.Empty,
                Validate = true
            };

            lbxOperadora.SelectedIndex = -1;
            this.IsNewOperadora = true;
            this.OperadoraEnabled = true;
            btnExcluir.Visibility = System.Windows.Visibility.Collapsed;
        }

        private void operadoras_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (lbxOperadora != null && lbxOperadora.SelectedIndex >= 0)
            {
                this.Operadora = lbxOperadora.SelectedItem as Operadora;

                if (this.Operadora.RegistroANS.Length == 6)
                {
                    this.Operadora.RegistroANS = this.Operadora.RegistroANS.Insert(5, "-");
                }
                this.Operadora.Validate = true;

                this.IsNewOperadora = false;
                this.OperadoraEnabled = true;
                btnExcluir.Visibility = System.Windows.Visibility.Visible;
            }
        }

        void client_OperadoraInsertCompleted(object sender, OperadoraInsertCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.Operadoras = null;
                client.OperadoraGetAllAsync(Util.Token);

                client.OperadoraGetAllFiliadoAsync(Util.Token);
                client.OperadoraGetAllNaoFiliadoAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Operadora cadastrada com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        void client_OperadoraGetAllCompleted(object sender, OperadoraGetAllCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else if (e.Result != null)
            {
                this.Operadoras = e.Result;
            }
        }

        void client_OperadoraDeleteCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.Operadoras = null;
                client.OperadoraGetAllAsync(Util.Token);

                client.OperadoraGetAllFiliadoAsync(Util.Token);
                client.OperadoraGetAllNaoFiliadoAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Operadora removida com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        void client_OperadoraUpdateCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.Operadoras = null;
                client.OperadoraGetAllAsync(Util.Token);

                client.OperadoraGetAllFiliadoAsync(Util.Token);
                client.OperadoraGetAllNaoFiliadoAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Operadora atualizada com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        #endregion

        #region Prestadores

        #region Prestadores
        public static readonly DependencyProperty PrestadoresProperty = DependencyProperty.Register("Prestadores",
            typeof(ObservableCollection<Prestador>), typeof(ConfigChildWindow), new PropertyMetadata(null));

        public ObservableCollection<Prestador> Prestadores
        {
            get { return (ObservableCollection<Prestador>)GetValue(PrestadoresProperty); }
            set { SetValue(PrestadoresProperty, value); }
        }
        #endregion

        #region PrestadorSelecionado
        public Prestador PrestadorSelecionado
        {
            get { return (Prestador)GetValue(PrestadorSelecionadoProperty); }
            set { SetValue(PrestadorSelecionadoProperty, value); }
        }

        public static readonly DependencyProperty PrestadorSelecionadoProperty =
            DependencyProperty.Register("PrestadorSelecionado", typeof(Prestador), typeof(ConfigChildWindow), new PropertyMetadata(null));
        #endregion

        #region PrestadorEnabled
        public static readonly DependencyProperty PrestadorEnabledProperty = DependencyProperty.Register("PrestadorEnabled",
            typeof(bool), typeof(ConfigChildWindow), new PropertyMetadata(false, new PropertyChangedCallback(PrestadorEnabledChanged)));

        public bool PrestadorEnabled
        {
            get { return (bool)GetValue(PrestadorEnabledProperty); }
            set { SetValue(PrestadorEnabledProperty, value); }
        }

        private static void PrestadorEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ConfigChildWindow myControl = d as ConfigChildWindow;

            if (myControl != null)
            {
                myControl.FirePropertyChanged("PrestadorNoErrors");
            }
        }

        #endregion

        #region IsNewPrestador
        public static readonly DependencyProperty IsNewPrestadorProperty = DependencyProperty.Register("IsNewPrestador",
            typeof(bool), typeof(ConfigChildWindow), new PropertyMetadata(false));

        public bool IsNewPrestador
        {
            get { return (bool)GetValue(IsNewPrestadorProperty); }
            set { SetValue(IsNewPrestadorProperty, value); }
        }
        #endregion

        #region PrestadorNoErrors
        private int prestadorErrorCount = 0;

        public bool PrestadorNoErrors
        {
            get
            {
                return (prestadorErrorCount == 0 && PrestadorEnabled);
            }
        }
        #endregion

        private void prestador_BindingValidationError(object sender, ValidationErrorEventArgs e)
        {
            switch (e.Action)
            {
                case ValidationErrorEventAction.Added:
                    prestadorErrorCount++;
                    break;
                case ValidationErrorEventAction.Removed:
                    prestadorErrorCount--;
                    break;
            }
            FirePropertyChanged("PrestadorNoErrors");
        }

        private void LimparPrestador()
        {
            this.PrestadorSelecionado = new LiveTissWCF.Prestador()
            {
                CEP = string.Empty,
                CodigoIBGE = string.Empty,
                CodigoUF = string.Empty,
                Complemento = string.Empty,
                Logradouro = string.Empty,
                Municipio = string.Empty,
                Nome = string.Empty,
                Numero = string.Empty,
                TipoLogradouro = string.Empty,
                Validate = false,
                LoginPrestador = new Login()
                {
                    IsAdministrator = false,
                    Senha = string.Empty,
                    SenhaNova = string.Empty,
                    SenhaConfirma = string.Empty,
                    Usuario = string.Empty,
                    Validate = false
                },
                ClinicaPrestador = null,
                ProfissionalPrestador = new Profissional() 
                {
                    CBOS = string.Empty,
                    CPF = string.Empty,
                    NumeroConselho = string.Empty,
                    SiglaConselho = string.Empty,
                    UFConselho = string.Empty,
                    Validate = false
                }
            };
            rdbPrestadorProfissional.IsChecked = this.PrestadorSelecionado.ProfissionalPrestador != null;
            rdbPrestadorHospital.IsChecked = this.PrestadorSelecionado.ClinicaPrestador != null;

            this.IsNewPrestador = false;
            this.PrestadorEnabled = false;

            lbxPrestador.SelectedIndex = -1;
            btnPrestadorExcluir.Visibility = System.Windows.Visibility.Collapsed;
        }

        private void txtPrestadorSenha_LostFocus(object sender, RoutedEventArgs e)
        {
            BindingExpression bindingExpression = null;

            bindingExpression = txtPrestadorSenha.GetBindingExpression(TextBox.TextProperty);
            bindingExpression.UpdateSource();

            bindingExpression = txtPrestadorSenhaConfirma.GetBindingExpression(TextBox.TextProperty);
            bindingExpression.UpdateSource();
        }

        private void txtPrestadorSenhaConfirma_LostFocus(object sender, RoutedEventArgs e)
        {
            BindingExpression bindingExpression = null;

            bindingExpression = txtPrestadorSenhaConfirma.GetBindingExpression(TextBox.TextProperty);
            bindingExpression.UpdateSource();

            bindingExpression = txtPrestadorSenha.GetBindingExpression(TextBox.TextProperty);
            bindingExpression.UpdateSource();
        }

        private void btnPrestadorSalvar_Click(object sender, RoutedEventArgs e)
        {
            if (PrestadorNoErrors)
            {
                if (this.IsNewPrestador)
                {
                    // Cadastrar novo
                    clientPrestadores.PrestadorInsertAsync(Util.Token, this.PrestadorSelecionado);
                }
                else
                {
                    // Salvar alterações
                    clientPrestadores.PrestadorUpdateAsync(Util.Token, this.PrestadorSelecionado);
                }
                LimparPrestador();
            }
        }

        private void btnPrestadorCancelar_Click(object sender, RoutedEventArgs e)
        {
            LimparPrestador();
        }

        private void btnPrestadorExcluir_Click(object sender, RoutedEventArgs e)
        {
            var alert = new AlertChildWindow();

            alert.Title = "Tem certeza que quer remover esse prestador?";
            alert.Width = 600;
            alert.Height = 200;

            alert.Closed += new System.EventHandler(alertPrestador_Closed);
            alert.Show(true);
        }

        private void alertPrestador_Closed(object sender, System.EventArgs e)
        {
            var alert = sender as AlertChildWindow;

            if ((bool)alert.DialogResult)
            {
                clientPrestadores.PrestadorDeleteAsync(Util.Token, this.PrestadorSelecionado);

                this.LimparPrestador();
            }
        }

        private void btnPrestadorNovo_Click(object sender, RoutedEventArgs e)
        {
            this.PrestadorSelecionado = new LiveTissWCF.Prestador()
            {
                CEP = string.Empty,
                CodigoIBGE = string.Empty,
                CodigoUF = string.Empty,
                Complemento = string.Empty,
                Logradouro = string.Empty,
                Municipio = string.Empty,
                Nome = string.Empty,
                Numero = string.Empty,
                TipoLogradouro = string.Empty,
                Validate = true,
                LoginPrestador = new Login()
                {
                    IsAdministrator = false,
                    Senha = string.Empty,
                    SenhaNova = string.Empty,
                    SenhaConfirma = string.Empty,
                    Usuario = string.Empty,
                    Validate = true,
                    ValidateNovo = true
                },
                ClinicaPrestador = null,
                ProfissionalPrestador = new Profissional()
                {
                    CBOS = string.Empty,
                    CPF = string.Empty,
                    NumeroConselho = string.Empty,
                    SiglaConselho = string.Empty,
                    UFConselho = string.Empty,
                    Validate = true
                }
            };

            rdbPrestadorProfissional.IsChecked = this.PrestadorSelecionado.ProfissionalPrestador != null;
            rdbPrestadorHospital.IsChecked = this.PrestadorSelecionado.ClinicaPrestador != null;

            this.IsNewPrestador = true;
            this.PrestadorEnabled = true;

            lbxPrestador.SelectedIndex = -1;
            btnPrestadorExcluir.Visibility = System.Windows.Visibility.Collapsed;
        }

        private void lbxPrestador_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (lbxPrestador != null && lbxPrestador.SelectedIndex >= 0)
            {
                this.PrestadorSelecionado = lbxPrestador.SelectedItem as Prestador;

                this.PrestadorSelecionado.Validate = true;

                if (this.PrestadorSelecionado.LoginPrestador != null)
                {
                    this.PrestadorSelecionado.LoginPrestador.Validate = true;
                }
                if (this.PrestadorSelecionado.ClinicaPrestador != null)
                {
                    this.PrestadorSelecionado.ClinicaPrestador.Validate = true;
                }
                if (this.PrestadorSelecionado.ProfissionalPrestador != null)
                {
                    this.PrestadorSelecionado.ProfissionalPrestador.Validate = true;
                }
                rdbPrestadorProfissional.IsChecked = this.PrestadorSelecionado.ProfissionalPrestador != null;
                rdbPrestadorHospital.IsChecked = this.PrestadorSelecionado.ClinicaPrestador != null;

                this.IsNewPrestador = false;
                this.PrestadorEnabled = true;
                btnPrestadorExcluir.Visibility = System.Windows.Visibility.Visible;
            }
        }

        private void rdbPrestadorHospital_Click(object sender, RoutedEventArgs e)
        {
            var prestador = this.PrestadorSelecionado;

            prestador.ProfissionalPrestador = null;
            prestador.ClinicaPrestador = new ClinicaHospital()
            {
                CNES = string.Empty,
                CNPJ = string.Empty,
                Validate = true
            };

            this.PrestadorSelecionado = prestador;

            rdbPrestadorProfissional.IsChecked = this.PrestadorSelecionado.ProfissionalPrestador != null;
            rdbPrestadorHospital.IsChecked = this.PrestadorSelecionado.ClinicaPrestador != null;
        }

        private void rdbPrestadorProfissional_Click(object sender, RoutedEventArgs e)
        {
            var prestador = this.PrestadorSelecionado;

            prestador.ProfissionalPrestador = new Profissional()
            {
                CBOS = string.Empty,
                CPF = string.Empty,
                NumeroConselho = string.Empty,
                SiglaConselho = string.Empty,
                UFConselho = string.Empty,
                Validate = true
            };
            prestador.ClinicaPrestador = null;

            this.PrestadorSelecionado = prestador;

            rdbPrestadorProfissional.IsChecked = this.PrestadorSelecionado.ProfissionalPrestador != null;
            rdbPrestadorHospital.IsChecked = this.PrestadorSelecionado.ClinicaPrestador != null;
        }

        void clientPrestadores_PrestadorInsertCompleted(object sender, PrestadorInsertCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else if (e.Result > 0)
            {
                this.Prestadores = null;
                clientPrestadores.PrestadorGetAllAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Prestador cadastrado com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        void clientPrestadores_PrestadorGetAllCompleted(object sender, PrestadorGetAllCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else if (e.Result != null)
            {
                this.Prestadores = e.Result;
            }
        }

        void clientPrestadores_PrestadorDeleteCompleted(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.Prestadores = null;
                clientPrestadores.PrestadorGetAllAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Prestador removido com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        void clientPrestadores_PrestadorUpdateCompleted(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.Prestadores = null;
                clientPrestadores.PrestadorGetAllAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Prestador atualizado com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        #endregion

        #region Configuracoes

        #region Operador Prestador

        #region OperadorasFiliadas
        public static readonly DependencyProperty OperadorasFiliadasProperty = DependencyProperty.Register("OperadorasFiliadas",
            typeof(ObservableCollection<Operadora>), typeof(ConfigChildWindow), new PropertyMetadata(null));

        public ObservableCollection<Operadora> OperadorasFiliadas
        {
            get { return (ObservableCollection<Operadora>)GetValue(OperadorasFiliadasProperty); }
            set { SetValue(OperadorasFiliadasProperty, value); }
        }
        #endregion

        #region OperadorasNaoFiliadas
        public static readonly DependencyProperty OperadorasNaoFiliadasProperty = DependencyProperty.Register("OperadorasNaoFiliadas",
            typeof(ObservableCollection<Operadora>), typeof(ConfigChildWindow), new PropertyMetadata(null));

        public ObservableCollection<Operadora> OperadorasNaoFiliadas
        {
            get { return (ObservableCollection<Operadora>)GetValue(OperadorasNaoFiliadasProperty); }
            set { SetValue(OperadorasNaoFiliadasProperty, value); }
        }
        #endregion

        #region OperadoraPrestador
        public static readonly DependencyProperty OperadoraPrestadorProperty = DependencyProperty.Register("OperadoraPrestador",
            typeof(OperadoraPrestador), typeof(ConfigChildWindow), new PropertyMetadata(null));

        public OperadoraPrestador OperadoraPrestador
        {
            get { return (OperadoraPrestador)GetValue(OperadoraPrestadorProperty); }
            set { SetValue(OperadoraPrestadorProperty, value); }
        }

        #endregion

        #region IsFiliada
        public static readonly DependencyProperty IsFiliadaProperty = DependencyProperty.Register("IsFiliada",
            typeof(bool), typeof(ConfigChildWindow), new PropertyMetadata(false));

        public bool IsFiliada
        {
            get { return (bool)GetValue(IsFiliadaProperty); }
            set { SetValue(IsFiliadaProperty, value); }
        }
        #endregion

        #region IsCodigoNaOperadora
        public bool IsCodigoNaOperadora
        {
            get
            {
                return (bool)rdbCodigoOperadora.IsChecked && rdbCodigoOperadora.IsEnabled;
            }
        }
        #endregion

        private void tvwOperadora_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
        {
            this.IntervaloLoteLista = null;
            this.OperadoraPrestador = null;
            this.IsFiliada = false;

            if (tvwOperadora.SelectedItem is Operadora)
            {
                var operadora = tvwOperadora.SelectedItem as Operadora;

                if (tviFiliadas.Items.Contains(tvwOperadora.SelectedItem))
                {
                    client.OperadoraPrestadorGetByIdAsync(Util.Token, operadora.RegistroANS, Util.Login.ID);
                }
                else if (tviNaoFiliadas.Items.Contains(tvwOperadora.SelectedItem))
                {
                    this.OperadoraPrestador = new OperadoraPrestador()
                    {
                        CodigoNaOperadora = string.Empty,
                        IDPrestador = Util.Login.ID,
                        RegistroANS = operadora.RegistroANS
                    };
                }
            }
            FirePropertyChanged("IsCodigoNaOperadora");
        }

        private void rdb_Click(object sender, RoutedEventArgs e)
        {
            if (!(bool)rdbCodigoOperadora.IsChecked)
            {
                this.OperadoraPrestador.CodigoNaOperadora = string.Empty;
            }
            FirePropertyChanged("IsCodigoNaOperadora");
        }

        private void btnConfiguracaoGravar_Click(object sender, RoutedEventArgs e)
        {
            if (this.IsFiliada)
            {
                client.OperadoraPrestadorUpdateAsync(Util.Token, this.OperadoraPrestador);
            }
            else
            {
                client.OperadoraPrestadorInsertAsync(Util.Token, this.OperadoraPrestador);
            }
            this.OperadoraPrestador = null;
        }

        private void btnConfiguracaoCancelar_Click(object sender, RoutedEventArgs e)
        {
            tvwOperadora.ClearSelection();
        }

        private void btnConfiguracaoExcluir_Click(object sender, RoutedEventArgs e)
        {
            var alert = new AlertChildWindow();

            alert.Title = "Tem certeza que quer desfiliar essa operadora?";
            alert.Width = 600;
            alert.Height = 200;

            alert.Closed += new System.EventHandler(config_Closed);
            alert.Show(true);
        }

        private void config_Closed(object sender, System.EventArgs e)
        {
            var alert = sender as AlertChildWindow;

            if ((bool)alert.DialogResult)
            {
                client.OperadoraPrestadorDeleteAsync(Util.Token, this.OperadoraPrestador);
                this.OperadoraPrestador = null;
            }
        }

        void client_OperadoraGetAllNaoFiliadoCompleted(object sender, OperadoraGetAllNaoFiliadoCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else if (e.Result != null)
            {
                this.OperadorasNaoFiliadas = e.Result;
            }
        }

        void client_OperadoraGetAllFiliadoCompleted(object sender, OperadoraGetAllFiliadoCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else if (e.Result != null)
            {
                this.OperadorasFiliadas = e.Result;
            }
        }

        void client_OperadoraPrestadorGetByIdCompleted(object sender, OperadoraPrestadorGetByIdCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else if (e.Result != null)
            {
                this.IsFiliada = true;
                this.OperadoraPrestador = e.Result;

                if (!string.IsNullOrEmpty(this.OperadoraPrestador.CodigoNaOperadora))
                {
                    rdbCodigoOperadora.IsChecked = true;
                }
                else
                {
                    rdbCPF.IsChecked = true;
                }

                client.IntervaloLoteGetAllByOperadoraPrestadorAsync(Util.Token, this.OperadoraPrestador.ID);

                FirePropertyChanged("IsCodigoNaOperadora");
            }
        }

        void client_OperadoraPrestadorDeleteCompleted(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.OperadorasFiliadas = null;
                this.OperadorasNaoFiliadas = null;

                client.OperadoraGetAllFiliadoAsync(Util.Token);
                client.OperadoraGetAllNaoFiliadoAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Operadora desfiliada com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        void client_OperadoraPrestadorUpdateCompleted(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.OperadorasFiliadas = null;
                this.OperadorasNaoFiliadas = null;

                client.OperadoraGetAllFiliadoAsync(Util.Token);
                client.OperadoraGetAllNaoFiliadoAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Operadora atualizada com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        void client_OperadoraPrestadorInsertCompleted(object sender, OperadoraPrestadorInsertCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else if (e.Result > 0)
            {
                this.OperadorasFiliadas = null;
                this.OperadorasNaoFiliadas = null;

                client.OperadoraGetAllFiliadoAsync(Util.Token);
                client.OperadoraGetAllNaoFiliadoAsync(Util.Token);

                var alert = new AlertChildWindow();

                alert.Title = "Operadora filiada com sucesso!";
                alert.Width = 500;
                alert.Height = 200;

                alert.Show();
            }
        }

        #endregion

        #region Intervalo Lote

        #region IntervaloLote
        public static readonly DependencyProperty IntervaloLoteProperty = DependencyProperty.Register("IntervaloLote",
            typeof(IntervaloLote), typeof(ConfigChildWindow), new PropertyMetadata(null, new PropertyChangedCallback(IntervaloLoteChanged)));

        public IntervaloLote IntervaloLote
        {
            get { return (IntervaloLote)GetValue(IntervaloLoteProperty); }
            set { SetValue(IntervaloLoteProperty, value); }
        }

        private static void IntervaloLoteChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ConfigChildWindow myControl = d as ConfigChildWindow;

            if (myControl != null)
            {
                myControl.FirePropertyChanged("IntervaloLoteNoErrors");
            }
        }
        #endregion

        #region IntervaloLoteLista
        public static readonly DependencyProperty IntervaloLoteListaProperty = DependencyProperty.Register("IntervaloLoteLista",
            typeof(ObservableCollection<IntervaloLote>), typeof(ConfigChildWindow), new PropertyMetadata(null));

        public ObservableCollection<IntervaloLote> IntervaloLoteLista
        {
            get { return (ObservableCollection<IntervaloLote>)GetValue(IntervaloLoteListaProperty); }
            set { SetValue(IntervaloLoteListaProperty, value); }
        }
        #endregion

        #region IntervaloLoteNoErrors
        private int intervaloLoteNoErrors = 0;

        public bool IntervaloLoteNoErrors
        {
            get
            {
                return (intervaloLoteNoErrors == 0 && this.IntervaloLote != null);
            }
        }
        #endregion

        private void lbxIntervaloLote_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            this.IntervaloLote = null;

            if (lbxIntervaloLote.SelectedItem is IntervaloLote)
            {
                this.IntervaloLote = lbxIntervaloLote.SelectedItem as IntervaloLote;
            }
        }

        private void btnIntervaloLoteNovo_Click(object sender, RoutedEventArgs e)
        {
            this.IntervaloLote = new IntervaloLote()
            {
                ID = -1,
                IDOperadoraPrestador = this.OperadoraPrestador.ID,
                Inicio = 0,
                Fim = 0,
                Atual = 0
            };
        }

        private void btnIntervaloLoteSalvar_Click(object sender, RoutedEventArgs e)
        {
            if (this.IntervaloLote.ID >= 0)
            {
                client.IntervaloLoteUpdateAsync(Util.Token, this.IntervaloLote);
            }
            else
            {
                client.IntervaloLoteInsertAsync(Util.Token, this.IntervaloLote);
            }

            this.IntervaloLote = null;
            lbxIntervaloLote.SelectedIndex = -1;
        }

        private void btnIntervaloLoteCancelar_Click(object sender, RoutedEventArgs e)
        {
            this.IntervaloLote = null;
            lbxIntervaloLote.SelectedIndex = -1;
        }

        private void intervaloLote_BindingValidationError(object sender, ValidationErrorEventArgs e)
        {
            switch (e.Action)
            {
                case ValidationErrorEventAction.Added:
                    intervaloLoteNoErrors++;
                    break;
                case ValidationErrorEventAction.Removed:
                    intervaloLoteNoErrors--;
                    break;
            }
            FirePropertyChanged("IntervaloLoteNoErrors");
        }

        void client_IntervaloLoteUpdateCompleted(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.IntervaloLote = null;
                this.IntervaloLoteLista = null;

                client.IntervaloLoteGetAllByOperadoraPrestadorAsync(Util.Token, this.OperadoraPrestador.ID);

                var alert = new AlertChildWindow();

                alert.Title = "Intervalo de lote atualizado com sucesso!";
                alert.Width = 600;
                alert.Height = 200;

                alert.Show();
            }
        }

        void client_IntervaloLoteInsertCompleted(object sender, IntervaloLoteInsertCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else
            {
                this.IntervaloLote = null;
                this.IntervaloLoteLista = null;

                client.IntervaloLoteGetAllByOperadoraPrestadorAsync(Util.Token, this.OperadoraPrestador.ID);

                var alert = new AlertChildWindow();

                alert.Title = "Intervalo de lote cadastrado com sucesso!";
                alert.Width = 600;
                alert.Height = 200;

                alert.Show();
            }
        }

        void client_IntervaloLoteGetAllByOperadoraPrestadorCompleted(object sender, IntervaloLoteGetAllByOperadoraPrestadorCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                // exception
            }
            else if (e.Result != null)
            {
                this.IntervaloLoteLista = e.Result;
            }
        }

        #endregion

        #endregion
    }
}

